


						130-309-001-03

SUBJECT:  PDP-11 FORTRAN OVERALL DESIGN SPECIFICATION

TO:  PDP-11 FORTRAN DESIGN REVIEW COMMITTEE	DATE:  10 DEC 70
     PDP-11 PROGRAMMERS

FROM:  DAVID KNIGHT
	LOU COHEN
	RON BRENDER


REFERENCE:	AMERICAN NATIONAL STANDARDS INSTITUTE
			FORTRAN IV SPECIFICATION








	COPYRIGHT 1970, DIGITAL EQUIPMENT CORPORATION







			COMPANY CONFIDENTIAL
			--------------------

		THIS DOCUMENT IS COMPANY CONFIDENTIAL AND
		IS FOR INTERNAL COMPANY USE ONLY.  COPYING
		IS EXPRESSLY FORBIDDEN.




		THE INFORMATION IN THIS MEMORANDUM IS
		SUBJECT TO CHANGE WITHOUT NOTICE AND
		SHOULD NOT BE CONSTRUED AS A COMMITMENT
		BY DIGITAL EQUIPMENT CORPORATION.
						130-309-001-03
						PAGE 2

			TABLE OF CONTENTS

1.0	OVERALL DESCRIPTION
1.1	USAGE
1.2	MARKET
1.3	DESIGN PHILOSOPHY

2.0	HARDWARE ENVIRONMENT
2.1	MINIMUM REQUIREMENTS
2.2	OPTIONS
2.3	FUTURE CONSIDERATIONS

3.0	SOFTWARE ENVIRONMENT
3.1	MINIMUM REQUIREMENTS
3.1.2	OBJECT TIME SYSTEM
	3.1.2.1 ARITHMETIC ROUTINES
	3.1.2.2 IF FUNCTIONS
	3.1.2.3 MOVE ROUTINES
	3.1.2.4 I/O ROUTINES
	3.1.2.5 PRINTING OF FORMATTED RECORDS
	3.1.2.6 SUBSCRIPT COMPUTATION
	3.1.2.7 STACK OVERFLOW
3.2	OPTIONS
3.3	FUTURE CONSIDERATIONS

4.0	CONVENTIONS AND STANDARDS
4.1	LABELING
4.1.1	COMPILER INTERNAL LABELLING
4.1.2	OBJECT OUTPUT LABELLING CONVENTIONS
4.2	REGISTERS
4.3	FORTRAN INTERNAL DOCUMENTATION
4.4	OPERATING CONVENTIONS
4.5	I/O
4.6	CHARACTER SET/CODES
4.7	CALLING CONVENTIONS
4.8	FORTRAN POLISH CALLS
4.9	DATA CONVENTIONS
4.9.1	INTEGER FORMAT
4.9.2	REAL FORMAT
4.9.3	DOUBLE PRECISION FORMAT
4.9.4	COMPLEX FORMAT
4.9.5	BYTE FORMAT
4.9.6	CHARACTER STRINGS
4.9.7	LOGICAL VALUES
4.10	FILE CONVENTIONS

5.0	DATA STRUCTURES
5.1	COMPILER DATA STRUCTURES
5.2	MAIN SYMBOL TABLE
5.3	COMMON TABLE
5.4	ARRAY DESCRIPTOR BLOCK
5.5	EQUIVALENCE TABLE
5.6	IMPLICIT TABLE
5.7	DO TABLE
5.8	OBJECT TIME DATA STRUCTURES

						130-309-001-03
						PAGE 3

6.0	INPUT/OUTPUT
6.1	COMPILER I/O
6.2	OBJECT TIME I/O
6.3	DIAGNOSTIC OUTPUT

7.0	LANGUAGE
7.1	SOURCE LANGUAGE
7.2	OBJECT LANGUAGE OUTPUT
7.3	OBJECT TIME EXCEPTIONS AND DIFFERENCES FROM ANSI FORTRAN
7.3.1	LIBRARY
7.3.2	COMPLEX FACILITIES
7.3.3	FORTRAN OVERLAYS
7.3.4	RANDOM ACCESS I/O

8.0	COMMAND LANGUAGE AND STRUCTURE

9.0	OPERATING PROCEDURES

10.0	PHYSICAL DESCRIPTION AND ORGANIZATION

11.0	FUNCTIONAL DESCRIPTION AND OPERATION

12.0	PROGRAMMING CONSIDERATIONS

13.0	PREPARATION AND/OR SYSTEM BUILD

14.0	MAINTENANCE CONSIDERATIONS

15.0	TERMINOLOGY
						130-309-001-03
						PAGE 4

1.0	OVERALL DESCRIPTION

1.1	USAGE

	FORTRAN IV IS A VERY WELL KNOWN ALGEBRAIC LANGUAGE
	(ORIGINALLY DESIGNED BY BACKUS, ET AL) IN COMMON
	USE ON MOST CURRENTLY AVAILABLE COMPUTERS.  IT IS
	DESCRIBED IN THE AMERICAN NATIONAL STANDARDS INSTITUTE
	FORTRAN IV LANGUAGE SPECIFICATION.

	PDP-11 FORTRAN IS A VARIANT OF ANSI STANDARD FORTRAN IV
	AS WILL BE DESCRIBED IN THIS AND ASSOCIATED DOCUMENTS.

	THE FORTRAN COMPILER IS USED IN CONJUNCTION WITH THE
	REMAINDER OF THE PDP-11 FORTRAN SYSTEM UNDER THE DISK
	MONITOR TO ALLOW USERS NOT FAMILIAR WITH ASSEMBLY
	LANGUAGE TECHNIQUES TO WRITE AND RUN PROGRAMS ON THE
	PDP-11.

1.2	MARKET

	POTENTIAL USERS OF FORTRAN ARE ASSUMED TO KNOW FORTRAN AND TO
	BE ABLE TO USE THE PDP-11 DISK MONITOR.  FORTRAN ALLOWS THE USER
	TO TAKE ADVANTAGE OF THE DISK MONITOR AND THE ASSOCIATED
	LIBRARY WITHOUT REQUIRING KNOWLEDGE OF ASSEMBLY
	LANGUAGE TECHNIQUES.  PDP-11 FORTRAN IS DESIGNED TO BE SALEABLE
	IN THE SAME MARKET AS THE IBM 1130.

1.3	DESIGN PHILOSOPHY

	PDP-11 FORTRAN WILL RUN UNDER THE PDP-11 DISK MONITOR,
	AND WILL THEREFORE REQUIRE A SYSTEM WITH AT LEAST 8K.

	PDP-11 FORTRAN WILL BE ANSI FORTRAN IV COMPATIBLE WITH
	ADDED FEATURES TO ALLOW IBM 1130 FORTRAN COMPATIBILITY
	AS WELL.

	THE PRIMARY CONSIDERATION IN THE FIRST PHASE OF COMPILER
	DEVELOPMENT IS THE ON TIME DELIVERY OF AN OPERATIONAL FORTRAN
	SYSTEM (JAN 31, 1971)TO PRODUCT TEST.

	THE COMPILER IS DESIGNED TO BE AS HELPFUL TO THE USER AS
	POSSIBLE IN TERMS OF DIAGNOSTIC CAPABILITIES AND OPERATING
	CHARACTERISTICS.
						130-309-001-03
						PAGE 5

2.0	HARDWARE ENVIRONMENT

2.1	MINIMUM REQUIREMENTS

	PDP-11 FORTRAN RUNS UNDER THE DISK MONITOR, WHICH
	REQUIRES A MINIMUM OF 8K OF CORE, RF-11 DISK,
	HIGH SPEED READER/PUNCH OR DECTAPE, AND AN ASR-33 TELETYPE.

2.2	OPTIONS

	IF MORE THAN 8K OF CORE IS AVAILABLE, FORTRAN WILL USE
	ALL AVAILABLE SPACE.  FORTRAN WILL SUPPORT
	ALL STANDARD PRODUCT LINE OPTIONS WHICH ARE SUPPORTED BY THE
	FIRST RELEASE (DECEMBER,1970) OF THE DISK MONITOR(DOS).

2.3	FUTURE CONSIDERATIONS

	THE SYSTEM MUST BE HIGHLY MODULAR TO ALLOW EXTENSIONS
	IN HARDWARE CONFIGURATION TO BE MADE WITH MINIMAL
	EFFORT.

	AT NO FUTURE TIME WILL FORTRAN BE SUPPORTED IN A PAPER TAPE
	ONLY ENVIRONMENT.
						130-309-001-03
						PAGE 6

3.0	SOFTWARE ENVIRONMENT

3.1	MINIMUM REQUIREMENTS

	FORTRAN WILL REQUIRE THE PDP-11 DISK MONITOR.  UNDER NO
	CIRCUMSTANCES WILL IT RUN IN THE PAPER TAPE SYSTEM.

	THE INITIAL VERSION OF THE COMPILER WILL OUTPUT CODE SUITABLE
	FOR ASSEMBLY BY THE RELOCATABLE ASSEMBLER.

3.1.2	OBJECT TIME SYSTEM

	3.1.2.1.  ARITHMETIC ROUTINES

	    EACH OF THE FOLLOWING IS CALLED USING THE POLISH
	    CALL(SECTION 4.8) WHICH ASSUMES THAT UPON ENTRY TO A ROUTINE,
	    REGISTER R4 POINTS TO A LOCATION CONTAINING THE ADDRESS
	    OF THE NEXT ROUTINE TO BE EXECUTED.  THUS, R4 MUST
	    BE PRESERVED BY THE ROUTINE AND THE EXIT FROM EACH
	    ROUTINE IS VIA A "JMP @(R4)+" WHICH JUMPS TO THE NEXT
	    ROUTINE AS WELL AS ADVANCING THE R4 POINTER.  THIS
	    WAY, THE COMPILER NEED ONLY GENERATE A LIST OF ADDRESSES
	    FOR MOST ARITHMETIC EXPRESSIONS WHICH IS
	    ONLY SLIGHTLY (APPROXIMATELY 1%) SLOWER THAN
	    IN-LINE JSR CALLS.	THE RESULTING CODE IS
	    USUALLY BETWEEN 10 AND 50% SHORTER THAN THE EQUIVALENT
	    IN-LINE CALL.

	    THE VALUE OF EACH OPERAND WILL BE ON THE STACK UPON
	    ENTRY TO A ROUTINE.  A ROUTINE RETURNS WITH
	    THE VALUE OF THE RESULT ON TOP OF THE STACK (THE ORIGINAL
	    OPERANDS WILL BE REMOVED FROM THE STACK).

	    THE MODE OF THE OPERANDS AND THE MODE OF THE RESULT WILL
	    BE DEFINED IMPLICITLY BY ENTRY INTO THE ROUTINE.

	    THE COMPILER WILL DISTINGUISH MODES BY SUFFIXING ONE
	    CHARACTER TO THE SUBROUTINE NAME.

	    ON ENTRY:

		(SP)	LAST (SECOND) OPERAND
		(SP+N)	FIRST OPERAND
	    WHERE N IS THE LENGTH IN BYTES OF EACH OPERAND.

	    UPON RETURN:

		(SP)	RESULT.
						130-309-001-03
						PAGE 7

	    THE SUFFIX WILL HAVE THE FOLLOWING SIGNIFICANCE:

		SUFFIX		OPERANDS	RESULT

		  I		INTEGER 	INTEGER
		  R		REAL		REAL
		  D		DOUBLE		DOUBLE
		  C		COMPLEX 	COMPLEX

	    THE ARITHMETIC ROUTINES ARE:

	NAME	FUNCTION

	 $AD	ADD FIRST OPERAND TO SECOND
			OPERAND
	 $SB	SUBTRACT THE SECOND OPERAND
		FROM THE FIRST OPERAND
	 $ML	MULTIPLY THE FIRST OPERAND
		BY THE SECOND OPERAND
	 $DV	DIVIDE THE FIRST OPERAND
		BY THE SECOND OPERAND
						130-309-001-03
						PAGE 8

	3.1.2.2.  IF FUNCTIONS

	    A.	ARITHMETIC IF TESTS WILL BE PERFORMED BY A SET OF
		ROUTINES WHOSE ENTRY POINT NAMES BEGIN WITH $TS
		WITH SUFFIXES AS DESCRIBED ABOVE.
		THE RETURN WILL BE TO ONE OF THREE LOCATIONS
		POINTED TO BY THE LOCATIONS AT (R4), (R4+2), AND (R4+4).

	    ON ENTRY:	     (SP) CONTAINS THE OPERAND TO BE TESTED.
	    AFTER RETURN:	THE STACK IS CLEAR.

	    B.	LOGICAL IF TESTS WILL BE PERFORMED BY A SET OF ROUTINES
		WHOSE ENTRY POINT NAMES BEGIN WITH $CM.
		TWO OPERANDS ARE COMPARED.
		THE RESULTS OF THE COMPARISON WILL
		BE LEFT IN THE CONDITION CODES UPON RETURN.

	       ROUTINE	PARAMETERS	MODE OF COMPARISON

		$CMR	  REAL			REAL
		$CMD	  DOUBLE		DOUBLE
		$CMC	  COMPLEX		COMPLEX

	RESULT IF FIRST < SECOND :   Z=0, N=1
	RESULT IF FIRST = SECOND :   Z=1, N=0
	RESULT IF FIRST > SECOND :   Z=0, N=0

		AFTER RETURN:  STACK IS CLEAR

	A SET OF ROUTINES EXISTS FOR CHECKING THE RESULT OF
	THE COMPARE.  THEY ARE CALLED AS $TXX WHERE XX STANDS FOR:

			EQ - EQUAL
			NE - NOT EQUAL
			LT - LESS THAN
			GT - GREATER THAN
			LE - LESS OR EQUAL
			GE - GREATER OR EQUAL

	THE $TXX ROUTINES REQUIRE ONE PARAMETER WHICH IS THE TRANSFER
	ADDRESS IN CASE OF TEST SATISFACTION.  WHEN CALLED, THEY
	ASSUME THE CONDITION CODES ARE SET PROPERLY AS DESCRIBED
	ABOVE.
						130-309-001-03
						PAGE 9

	3.1.2.3.  DATA CONVERSION ROUTINES.

	    THE OPERAND ON THE STACK IS CONVERTED TO THE DESTINATION MODE
	    AND REPLACES THE SOURCE OPERAND ON THE TOP OF THE STACK.
	    THE STACK IS CLEARED.

	ROUTINE 	OPERAND 	RESULTING MODE

	  $RI	REAL			INTEGER
	  $DI	DOUBLE PRECISION	INTEGER
	  $IR	INTEGER 		REAL
	  $DR	DOUBLE PRECISION	REAL
	  $ID	INTEGER 		DOUBLE PRECISION
	  $RD	REAL			DOUBLE PRECISION

						130-309-001-03
						PAGE 10

	3.1.2.4.  I/O ROUTINES

	    EACH I/O OPERATION INVOLVES AN INITIALIZATION CALL;
	    THEN ONE OR MORE CALLS TO TRANSMIT ONE OR MORE LIST VARIABLES
	    PER CALL, THEN A CALL TO TERMINATE THE I/O OPERATION.

				(SP)		(SP+2)
	INITIALIZE:

	$INFI,FORMATTED READ	ADDRESS OF	ADDRESS OF 1ST
	$OUTFI,FORMATTED WRITE	DEVICE NUMBER	CHARACTER OF
						FORMAT STRING
	$INI,UNFORMATTED READ	ADDRESS OF
	$OUTI,UNFORMATTED WRITE DEVICE NUMBER

	$INRI,DISK READ 	ADDRESS OF	ADDRESS OF LOGICAL
	$OUTRI,DISK WRITE	DEVICE NUMBER	RECORD NUMBER

	EACH INITIALIZATION CALL HAS TWO IN-LINE PARAMETERS CORRESPONDING
	TO THE "END=" AND "ERR=" CONDITIONS.  IF EITHER OF THESE
	PARAMETERS ARE ZERO, THE CONDITION IS NOT SPECIFIED.  IF
	NON-ZERO, THEY ARE THE ADDRESS OF THE STATEMENT TO BE
	TRANSFERRED TO.  THIS TRANSFER MUST BE A POLISH MODE
	TRANSFER.

	TRANSMIT LIST VARIABLES:

	$IOA - TRANSMIT ARRAYS
	$IOB - TRANSMIT BYTE LENGTH ITEM
	$IOI - TRANSMIT SINGLE WORD INTEGER OR LOGICAL
	$IOJ - TRANSMIT TWO WORD INTEGER OR LOGICAL
	$IOR - TRANSMIT REAL
	$IOD - TRANSMIT DOUBLE
	$IOC - TRANSMIT COMPLEX

	ONE OR MORE PARAMETERS MAY BE TRANSMITTED, (SP) CONTAINS
	THE NUMBER OF PARAMETERS, (SP+2) - (SP+N) CONTAIN THE
	ADDRESSES OF EACH DATA ITEM.  NOTE THAT ALL CONSECUTIVE
	ITEMS OF THE SAME TYPE WILL BE TRANSFERRED TOGETHER.

	FOR ARRAY I/O, ALL CONSECUTIVE ARRAYS WILL HAVE THEIR
	ADB ADDRESSES PUSHED ON THE STACK FOLLOWED BY THE NUMBER OF
	ARRAYS.  A CALL TO $IOA WILL THEN BE MADE TO CAUSE THE
	ARRAY TRANSFER.  THE OTS MAY DETERMINE THE DATA TYPE OF THE ARRAY
	BY EXAMINING THE ADB(SEE SECTION 3.1.2.6).



	TERMINATE:

	$IOF, TERMINATE I/O LIST
						130-309-001-03
						PAGE 11

	3.1.2.5.  PRINTING OF FORMATTED RECORDS.

	    THE OTS WILL MAINTAIN A FILE/DEVICE TABLE (WHICH SHOULD
	    BE MODIFIABLE BY THE USER) WHICH, ALONG WITH OTHER
	    FUNCTIONS, INDICATES FOR EACH LOGICAL FILE WHETHER THE
	    FIRST CHARACTER IN A FORMATTED RECORD SHOULD BE TRANSMITTED
	    LITERALLY OR SHOULD BE INTERPRETED FOR PRINT CONTROL PUR-
	    POSES.

	    WHEN THE TABLE SO INDICATES, THE VERTICAL SPACING CHAR-
	    ACTER SHOULD BE INTERPRETED AND THEREFORE CONVERTED INTO
	    AN OUTPUT STRING AS FOLLOWS:

	    VERTICAL SPACING CHARACTER	MEANING 	SUBSTITUTED
							OUTPUT STRING

		BLANK			SPACE ONE LINE	<CR,LF>

		0			SPACE TWO LINES <CR,LF,LF>

		1			SPACE TO FIRST	<CR,FF>
					LINE OF NEXT
					PAGE

		+			NO ADVANCE	<CR>

	    THE MONITOR PROVIDES DEVICE INDEPENDENCE AS REGARDS THE
	    LINE PRINTER AND THE TELETYPE; THEREFORE THE SAME SUBSTITUTED
	    OUTPUT STRING APPLIES TO EITHER DEVICE.
						130-309-001-03
						PAGE 12

	3.1.2.6.  SUBSCRIPT COMPUTATION.  THERE WILL BE THREE SUBSCRIPT COMPU-
	    TATION ROUTINES, ONE FOR EACH OF 1,2,AND 3 DIMENSIONAL
	    ARRAYS.  THE CALL TO A SUBSCRIPT ROUTINE WILL
	    HAVE AS A SINGLE IN-LINE PARAMETER AN
	    ARRAY DESCRIPTOR BLOCK (GENERATED BY THE COMPILER, AND FOR
	    ADJUSTABLE ARRAYS, INITIALIZED BY THE OBJECT CODE ITSELF),
	    AS WELL AS TO THE CURRENT INDEX VALUES ON THE STACK.
	    THE SUBSCRIPT ROUTINE WILL RETURN WITH THE ADDRESS OF
	    THE DESIRED ARRAY ITEM IN R0.

	    THE ARRAY DESCRIPTOR BLOCK (ADB) FORMAT IS AS FOLLOWS:

	    WORD 0:	ADDRESS OF THE FIRST ELEMENT OF THE ARRAY. (ADDR)

	    WORD 1:	BITS 13-11: DATA TYPE
			BITS 7-0: SIZE IN BYTES OF AN ARRAY DATA ELEMENT
			(ABBREVIATED: SIZE)

	    WORD 2:	NUMBER OF INDEX ITEMS FOR THE FIRST DIMENSION(ABBR.:A)
			(ALWAYS PRESENT)

	    WORD 3:	NUMBER OF INDEX ITEMS FOR THE SECOND DIMENSION
			(ABBR.: B) (PRESENT FOR 2 AND 3 DIMENSIONAL ARRAYS)

	    WORD 4:	NUMBER OF INDEX ITEMS FOR THE THIRD DIMENSION
			(ABBR.:C) (PRESENT FOR 3 DIMENSIONAL ARRAYS)

	THE SUBSCRIPT ROUTINES MAY, WITH THE INFORMATION SUPPLIED,
	IF DESIRED CHECK FOR REFERENCES EXCEEDING THE
	BOUNDARIES OF THE ARRAY(AT A FUTURE DATE).


ROUTINE NAME		$SBS3		$SBS2		$SBS1


(SP) UPON ENTRY		 VALUE OF 1ST	VALUE OF 1ST	VALUE OF 1ST
			INDEX(I)	INDEX(I)	INDEX(I)

(SP+2) UPON ENTRY	VALUE OF 2ND	VALUE OF 2ND
			INDEX(J)	INDEX(J)

(SP+4) UPON ENTRY	VALUE OF 3RD
			INDEX(K)

R0 AFTER RETURN 	ADDR+((I-1)+	ADDR+((I-1)+	ADDR+(I-1)
CONTAINS THE ADDRESS:	A*((J-1)+B*	A*(J-1))*SIZE	*SIZE
			(K-1)))*SIZE
						130-309-001-03
						PAGE 13

	3.1.2.7.  STACK OVERFLOW.

	    THE COMPILER WILL CALCULATE THE MAXIMUM DEPTH TO WHICH THE
	    STACK OBTAINS DURING EXECUTION OF EACH SUBPROGRAM IT COMPILES,
	    AND WILL GENERATE OBJECT CODE TO PASS THIS NUMBER (N)
	    AS AN IN-LINE PARAMETER TO THE OTS VIA A POLISH CALL
	    TO SUBROUTINE $CK UPON ENTRY TO THE SUBPROGRAM.
	    $CK WILL SUBTRACT (N+K) FROM THE STACK POINTER TO DETERMINE
	    WHETHER STACK OVERFLOW WILL OCCUR IF THE SUBPROGRAM IS
	    ALLOWED TO EXECUTE.  AN APPROPRIATE DIAGNOSTIC SHOULD BE
	    ISSUED BY THE OTS IF STACK OVERFLOW IS IMMINENT.

	    K IS A VALUE TO BE DETERMINED EMPIRICALLY BY OBSERVATION OF
	    THE EFFECTS ON THE STACK BY THE OBJECT TIME SYSTEM AND BY
	    THOSE FUNCTIONS OF THE MONITOR WHICH IT USES.

3.2	OPTIONS

	1.  A COMPILE TIME OPTION TO TURN OFF THE STACK OVERFLOW
	CHECK WILL BE AVAILABLE.
	2.  A COMPILE TIME OPTION TO SELECT ONE OR TWO WORD
	INTEGERS WILL BE AVAILABLE.  NOTE THAT THIS DOES NOT
	CURRENTLY IMPLY TWO WORDS OF INTEGER PRECISION.

3.3	FUTURE CONSIDERATIONS

	PROVISIONS MUST BE MADE TO ALLOW THE COMPILER
	AT A FUTURE DATE, TO DO ITS OWN BINARY OUTPUT(WITH
	THE ATTENDANT REQUIREMENTS FOR CREF AND DDT
	OUTPUTS).
						130-309-001-03
						PAGE 14

4.0	CONVENTIONS AND STANDARDS

4.1	LABELLING

4.1.1	COMPILER INTERNAL LABELLING

	ROUTINE OR MODULE LABELS MAY CONSIST OF ONE TO SIX
	CHARACTERS AND SHOULD, IF POSSIBLE, BE SELF-DESCRIPTIVE.

	EXAMPLE:	THE SYMBOL "LPTINT" COULD REFER TO AN
			INTERRUPT ADDRESS FOR A LINE PRINTER
			ROUTINE.

4.1.2	OBJECT OUTPUT LABELLING CONVENTIONS

4.1.2.1	LABELS

	A STATEMENT LABEL CONSISTS OF A "." FOLLOWED BY THE
	SOURCE STATEMENT LABEL.

		EXAMPLE:  STATEMENT NUMBER 237 WOULD GENERATE
		AN INTERNAL LABEL OF .237

	A FORMAT LABEL IS SIMILAR BUT USES A "$" INSTEAD OF A "." .

		EXAMPLE:  $10

	OTHER COMPILER GENERATED LABELS WILL CONSIST OF A "." OR "$"
	FOLLOWED BY A SINGLE ALPHABETIC CHARACTER DESCRIBING THE LABEL
	FOLLOWED BY 4 NUMERIC DIGITS.  THE FOLLOWING IS A LIST OF
	ALLOWED LABELS (NNNN REFER TO THE FOUR NUMERIC DIGITS):

	$INNNN	INTEGER CONSTANT	.INNNN	INTEGER TEMPORARY
	$RNNNN	REAL CONSTANT		.RNNNN	REAL TEMPORARY
	$DNNNN	DOUBLE CONSTANT 	.DNNNN	DOUBLE OR COMPLEX TEMP.
	$CNNNN	COMPLEX CONSTANT

	$FNNNN	INTERNAL LOCATION LABELS (FOR EXAMPLE, DO LOOP TERMINATION
		LABEL)
						130-309-001-03
						PAGE 15

4.1.2.2	ROUTINE NAMES

	THE COMPILER WILL GENERATE THE FOLLOWING SEQUENCES FOR
	THE FOLLOWING ROUTINES.

	EACH ROUTINE NAME CONSISTS OF A BASIC NAME FOLLOWED BY
	A ONE CHARACTER SUFFIX DESCRIBING THE MODE OR TYPE
	OF OPERATION.  ROUTINES ARE:

		$AD - ADD TOP STACK ITEM TO SECOND STACK ITEM AND
		      PLACE RESULT IN TOP OF STACK.
		$SB - SUBTRACT TOP STACK ITEM FROM SECOND ITEM AND
		      PLACE RESULT IN TOP OF STACK.
		$ML - MULTIPLY TOP STACK ITEM BY SECOND STACK ITEM
		$DV - DIVIDE TOP ITEM ON STACK BY SECOND ITEM ON STACK
		$CM - COMPARE TOP STACK ITEM WITH SECOND STACK ITEM.
		      SET THE CONDITION CODES ACCORDINGLY.

	NOTE THAT EACH "ITEM" REFERRRED TO ABOVE IS THE
	VALUE OF THE DESIRED DATUM.

	THE ALLOWABLE SUFFIXES ARE:

		I - INTEGER
		R - REAL
		D - DOUBLE
		C - COMPLEX

	EXAMPLE:  THE POLISH CALL $ADR WILL ADD TOP ITEM ON THE
	STACK TO A REAL SECOND ITEM AND RETURN A REAL RESULT ON THE TOP
	OF THE STACK.

	SEE SECTION 3.1.2
						130-309-001-03
						PAGE 16

4.2	REGISTERS

	TO AVOID CONFUSION, THE GENERAL REGISTERS WILL ALWAYS BE
	REFERRED TO AS FOLLOWS:

		REGISTERS 0-5 = R0-R5
		REGISTER   6  = SP
		REGISTER   7  = PC

	CERTAIN SPECIAL REGISTERS WILL BE REFERRED TO ACCORDING
	TO THE FOLLOWING:

	  STATUS REGISTER (LOC. 177776)  = STATUS
	  SWITCH REGISTER (LOC. 177570)  = SWREG

	IN A FORTRAN COMPILED ROUTINE, NO REGISTERS WILL EVER
	BE SAVED OR RESTORED UPON CALLING OR BEING CALLED BY AN
	EXTERNAL ROUTINE.  IT IS ASSUMED THAT R5 IS THE SUBROUTINE
	CALL REGISTER, AND THAT R0-R4 MAY BE USED WITHOUT
	PREJUDICE.

4.3	THE FORTRAN INTERNAL DOCUMENTATION WILL CONSIST OF:

	A.  ANSI FORTRAN IV SPECIFICATION
	B.  THIS DOCUMENT
	C.  INDIVIDUAL SPECIFICATIONS FOR
		1.  COMPILER
		2.  MATH PACKAGE
		3.  OBJECT TIME SYSTEM
		4.  GENERAL UTILITIES
	D.  PERTINENT AND PROFUSE COMMENTS ON THE SOURCE LISTINGS.
	E.  OVERALL BLOCK DIAGRAM FOR EACH MAJOR SECTION OF THE
	    SYSTEM.
	F.  DETAILED BLOCK DIAGRAMS FOR ANY POTENTIALLY
	    CONFUSING AREAS.
	G.  TEST PLANS.

						130-309-001-03
						PAGE 17

4.4	OPERATING CONVENTIONS

	ALL OPERATING CONVENTIONS AND COMMAND STRINGS, ETC. MUST
	CONFORM TO THOSE OF THE DISK MONITOR.

4.5	I/O

	ALL INPUT AND OUTPUT FOR FORTRAN WILL BE DONE USING THE
	STANDARD PROVISIONS SUPPLIED BY THE DISK MONITOR.

4.6	CHARACTER SET/CODES

	THE CHARACTER SET/CODES FOR FORTRAN WILL BE COMPLETELY
	COMPATIBLE WITH THE ANSI ASCII CONVENTIONS.

	THE COMPILER WILL NOT CONVERT LOWER CASE TO UPPER CASE, THOUGH
	LOWER CASE MAY BE USED ONLY IN HOLLERITH CONSTANTS AND
	LITERAL STRINGS.  ILLEGAL NON-PRINTING
	CHARACTERS ARE PRINTED AS A CIRCUMFLEX (UP ARROW) FOLLOWED BY THE
	ALPHABETIC EQUIVALENT OF THE OFFENDING CHARACTER (E.G. 001=^A).
	THE OTS WILL ALLOW ALL ASCII CHARACTERS TO BE INPUT OR OUTPUT
	UNDER "A" FORMAT.  THE COMPILER RECOGNIZES AS MEANINGFUL ONLY THE
	ANSI STANDARD COMPILER INPUT CHARACTERS.

4.7	CALLING CONVENTIONS

4.7.1	FORTRAN SUBROUTINE CALLS

	FORTRAN OBJECT TIME SUBROUTINES WILL OBEY THE FOLLOWING
	CALLING CONVENTIONS:

	ALL ARGUMENT ADDRESSES WILL BE PLACED IN A LIST FOLLOWING
	THE SUBPROGRAM CALL.  THE STANDARD SEQUENCE WILL BE:

		.GLOBL	SUBR
		JSR	R5,SUBR
		BR	XX
		A
		B
		.
		.
		.
		Z
	XX:

	NOTE:  THE EVEN BYTE OF THE BRANCH INSTRUCTION
	FOLLOWING THE JSR CONTAINS THE NUMBER OF ARGUMENTS
	AND IS POINTED TO BY R5.

	SUBPROGRAMS ARE RESPONSIBLE FOR NOT ALTERING THE CONTENTS
	OF ANY REGISTERS.

	FUNCTION SUBPROGRAMS, IN ADDITION TO THE ABOVE, WILL
	RETURN THE RESULT IN REGISTERS R0-R3(NUMBER OF REGISTERS
	USED IS DEPENDENT ON TYPE, E.G. - INTEGER USES R0, REAL
	USES R0 AND R1, ETC.)
						130-309-001-03
						PAGE 18

4.8	FORTRAN POLISH CALLS (THREADED CODE)

	THIS CALL IS DESIGNED TO TAKE ADVANTAGE OF THE SIMPLE
	POLISH METHOD FOR EVALUATING EXPRESSIONS.  IT ASSUMES
	THAT A TYPICAL EXPRESSION CONSISTS OF A LARGE NUMBER
	OF VERY SIMPLE OPERATIONS DONE IN A LINEAR SEQUENCE.

	THE IMPLEMENTATION OF THIS TECHNIQUE AS DESCRIBED BELOW
	MAKES SEVERAL ASSUMPTIONS:

	1.  THE FIRST OPERATION DONE IN A POLISH SEQUENCE IS
	INVARIABLY A PUSH.
	2.  IT IS NOT NECESSARY TO PLACE BREAKPOINTS(AS IN ODT OR
	DDT) IN THE MIDDLE OF AN ARITHMETIC STATEMENT.
	3.  SPEED WILL NOT SUFFER BY THE ASSIGNMENT OF A REGISTER
	FOR SPECIAL PURPOSES.

	DESCRIPTION OF THIS MODE IS BEST DONE USING A SIMPLE
	EXAMPLE:

	THE STATEMENT A=B+C WOULD GENERATE CODE SIMILAR TO THE
	FOLLOWING(SECTION 4.8.9 DESCRIBES ENTERING POLISH MODE).

		PUSHB	;THE VARIABLE B GETS PUSHED ON THE STACK
		PUSHC	;EACH OPERATION CONSISTS OF THE
		ADDF	;ADDRESS OF THE ROUTINE
		POPF	;TO BE EXECUTED.  A PUSH PLACES A VALUE
		A	;ON THE STACK, A POP REMOVES A VALUE.
		.+2	;THIS LINE CAUSES POLISH MODE TO BE
			;EXITED, AND NORMAL EXECUTION RESUMED.

	THE SUBROUTINES CALLED WOULD LOOK LIKE THE FOLLOWING:

	PUSHB:	MOV	B+2,-(SP)	;PUSH B
		MOV	B,-(SP) 	; ON STACK
		JMP	@(R4)+		;JUMP TO NEXT ROUTINE
	PUSHC:	MOV	C+2,-(SP)	;PUSH C
		MOV	C,-(SP)		; ON STACK
		JMP	@(R4)+		;JUMP TO NEXT ROUTINE
	POPF:	MOV	(R4)+,R3	;GET ADDRESS OF VARIABLE
		MOV	(SP)+,(R3)+	;TO POP, THEN STORE
		MOV	(SP)+,(R3)+	;POPPED VALUE
		JMP	@(R4)+		;AND CONTINUE

	(ADDF IS AN OTS ROUTINE)
						130-309-001-03
						PAGE 19

	NOTE THAT THE JMP @(R4)+ JUMPS TO THE NEXT ROUTINE IN THE
	LIST AS WELL AS INCREMENTING R4 OVER THAT ITEM IN THE THREAD.

	ALL INTERNAL FUNCTIONS ARE CALLED IN THIS MANNER AND MUST
	EXIT USING A JMP @(R4)+ AND MUST CLEAR ANY STACK SPACE
	USED(EXCEPT FOR THE RETURN VALUE WHICH IS LEFT ON THE TOP
	OF THE STACK).

	ALL ROUTINES EXPLICITLY CALLABLE BY THE USER
	(I.E. - SUBROUTINES, EXTERNAL FUNCTIONS) ARE CALLED
	USING THE PDP-11 SUBROUTINE CALLING CONVENTION.

4.8.1	SEVERAL SECTIONS OF CODE HAVE BEEN WORKED OUT
	TO DETAIL THE REQUIREMENTS OF THE FORTRAN
	COMPILER.  EXAMPLES ARE PRESENTED BELOW.  IN ADDITION
	THE FOLLOWING DECISIONS WERE MADE:

	1.  R4 WILL BE USED AS THE THREADED CODE POINTER.

	2.  IT NOW APPEARS THAT ALMOST ALL CODE (INCLUDING INTEGER
	    ARITHMETIC) WILL BE HANDLED IN POLISH MODE EXCEPT FOR
	    ACTUAL SUBROUTINE (AND FUNCTION) LINKAGE WHICH WILL BE
	    EXECUTED IN-LINE.

	3.  A MAJORITY OF THE SERVICE ROUTINES DETAILED HEREIN CAN
	    ACTUALLY BE MADE .GLOBAL TO THE COMPILATION AND HENCE
	    OCCUR ONLY ONCE IN A CORE LOAD (RATHER THAN INCLUDED
	    IN EACH COMPILED MODULE).

	4.  ANY ROUTINES NOT EXPLICITLY MENTIONED AS BEING
	    LOCALLY GENERATED ARE ASSUMED TO BE GLOBAL TO THE
	    PROGRAM AND AVAILABLE FROM THE FORTRAN LIBRARY
	    (E.G. - $MLF, ETC.)

	IN THE CODE BELOW SOME POLISH HANDLERS REQUIRE ONE OR MORE
	PARAMETERS.  THESE ARE LISTED ON THE SAME LINE AS THE
	HANDLER ENTRY ADDRESS FOR CLARITY EVEN THOUGH THEY OCCUPY
	CONSECUTIVE WORDS.

	EXAMPLE #1

	C	IN A MAIN PROGRAM
		A=B*C+A

	COMPILES AS--

	;ASSUME ALREADY IN POLISH MODE--SEE LATER DISCUSSION
		$P.B		;PUSH VALUE OF B
		$P.C		;PUSH C
		$MLF		;FLOATING MULTIPLY
		$P.A		;PUSH A
		$ADF		;FLOATING ADD
		$POP2,A 	;POP STACK INTO A

	(SEE EXAMPLE #2 FOR CODE FOR $P.A, $P.C, ETC.
						130-309-001-03
						PAGE 20

	EXAMPLE #2

	C	T1 IS AN EXTERNAL FUNCTION, A AND B ARE ARRAYS
	C	ALSO IN MAIN PROGRAM
		A(I+J)=C*T1(C,D+E,F+E)+B(3)

	COMPILES AS--

		$P.C		;PUSH C
		$P.D		;PUSH D
		$P.E		;PUSH E
		$ADF		;ADD D,E
		$SVSP,$L0+10	;STORE POINTER TO D+E INTO CALL SEQUENCE
		$P.F		;PUSH F
		$P.E		;PUSH E
		$ADF		;ADD
		$SVSPX,$L0+12	;STORE POINTER TO F+E INTO CALL
				;AND EXIT POLISH MODE
	$L0:	JSR R5,T1	;CALL T1
		BR .+10 	;3 PARAMETERS
		C		;SIMPLE PARAMETERS ARE COMPILED IN-LINE
		0
		0
		ADD #4,SP	;CLEAN UP TEMPORARIES USED IN CALL
		JSR R4,$POLSH	;RETURN TO POLISH MODE
		$PSHR2		;PUSH RESULT OF CALL ONTO STACK
		$MLF		;C*T1(...)
		$P.3		;SUBSCRIPT OF B TO STACK
		$SBS1,$ADB.B	;DO SUBSCRIPT COMPUTATION
				;ADDRESS OF ELEMENT RETURNED IN R0
		$GET2		;GET FLOATING VALUE POINTED AT BY R0
		$ADF		;C*T1(...)+B(3)
		$P.I		;PUSH I
		$P.J		;PUSH J
		$ADI		;I+J
		$SBS1,$ADB.A	;A(I+J)--ADDRESS IN R0
		$PUT2		;TOP OF STACK STORED VIA R0
						130-309-001-03
						PAGE 21

4.8.2	SERVICE ROUTINES REQUIRED LOOK LIKE THE FOLLOWING:

	$P.A:	MOV	A+2,-(SP)	;LOW PART FIRST!
		MOV	A,-(SP)
		JMP	@(R4)+		;ONTO THE NEXT

	FOR AN INTEGER VALUE, WE HAVE:

	$P.I:	MOV	I,-(SP)
		JMP	@(R4)+

	ONE SUCH SERVICE ROUTINE IS REQUIRED FOR EACH SIMPLE VALUE
	(NON-ARRAY) IN EACH COMPILATION.  STORES ARE BELIEVED TO BE
	FAR LESS FREQUENT THAN LOADS AND HENCE ARE SERVICED BY A
	GENERAL $POP WITH A PARAMETER TO GIVE THE DESTINATION.	ITS
	FORMS ARE

	$POP2:	MOV	(R4)+,R3	;GET DESTINATION
		MOV	(SP)+,(R3)+	;COPY FLOATING VALUE
		MOV	(SP)+,(R3)+
		JMP	@(R4)+

	$POP1:	MOV	(SP)+,@(R4)+	;COPY INTEGER VALUE
		JMP	@(R4)+

4.8.3	SAVING ADDRESSES INLINE COME IN TWO FLAVORS - ONE STAYS IN
	POLISH MODE, THE OTHER LEAVES POLISH MODE ON RETURN AND IS USED
	WHEN THE LAST PARAMETER OF A CALL IS AN EXPRESSION.

	$SVSP:	MOV	SP,@(R4)+
		JMP	@(R4)+

	$SVSPX: MOV	SP,@(R4)+
		JMP	@R4		;THIS EXITS POLISH MODE.

4.8.4	SIMILAR ROUTINES ARE REQUIRED TO HANDLE THE SAVING OF THE BASE
	ADDRESS OF AN ARRAY ELEMENT WHEN USED IN A CALL. E.G.:

		CALL SUB(B(I))

	WOULD GENERATE

		$P.I			;PUSH I
		$SBS1,$ADB.B		;COMPUTE SUBSCRIPT, LEAVE IN R0
		$SVR0X,$L1+6		;SAVE BASE IN CALL SEQUENCE
	$L1:	JSR	R5,SUB		;CALL SUB
		BR	.+4		;ONE PARAMETER
		0			;NO STACK CLEAN-UP NEEDED.
						130-309-001-03
						PAGE 22

4.8.5	ON RETURN FROM A ROUTINE THE VALUE IS IN R0, R0 AND R1, OR
	R0 THRU R3.  SERVICE ROUTINES TO MOVE THESE TO STACK ARE:

	$PSHR4: MOV	R3,-(SP)	;PUSH FOUR WORDS
		MOV	R2,-(SP)
	$PSHR2: MOV	R1,-(SP)	;ENTER HERE TO PUSH TWO
	$PSHR1: MOV	R0,-(SP)	;ENTER HERE TO PUSH ONE
		JMP	@(R4)+

4.8.6	IF AN ASSIGNMENT OPERATION IMMEDIATELY FOLLOWS A FUNCTION
	RETURN, AS IN X=SIN(A), THEN A DIRECT MOVE TO X CAN BE ACCOM-
	PLISHED VIA

	$CORE4: MOV	R0,@(R4)
		MOV	(R4)+,R0
		TST	(R0)+
		MOV	R1,(R0)+
		MOV	R2,(R0)+
		MOV	R3,(R0)+
		JMP	@(R4)+
	$CORE2: MOV	(R4)+,R3
		MOV	R0,(R3)+
		MOV	R1,(R3)+
		JMP	@(R4)+

	$CORE1: MOV	R0,@(R4)+
		JMP	@(R4)+

4.8.7	GETTING AND PUTTING TO THE STACK GIVEN AN ADDRESS WHICH RESULTS
	FROM SUBSCRIPT CALCULATION PROCEEDS AS FOLLOWS:

	$GET4:	MOV	6(R0),-(SP)	;FOUR WORD CASE
		MOV	4(R0),-(SP)
	$GET2:	MOV	2(R0),-(SP)	;TWO WORD CASE
	$GET1:	MOV	@R0,-(SP)	;ONE WORD CASE
		JMP	@(R4)+

	$PUT4:	MOV	(SP)+,(R0)+
		MOV	(SP)+,(R0)+
	$PUT2:	MOV	(SP)+,(R0)+
	$PUT1:	MOV	(SP)+,(R0)+
		JMP	@(R4)+
						130-309-001-03
						PAGE 23

4.8.8	EXPLICIT EXIT FROM POLISH MODE CAN BE MADE WITH A WORD CONTAINING
	THE ADDRESS OF THE FOLLOWING WORD, EG:

		...			;IN POLISH MODE
		.WORD	.+2		;LEAVE POLISH MODE
		...			;CONTROL PASSES TO HERE

4.8.9	ENTRY TO POLISH MODE IS MADE VIA A SPECIAL ROUTINE

	$POLSH: TST	(SP)+		;DELETE USELESS OLD VALUE OF
					;R4 PUSHED ON ENTRY BY JSR
		JMP	@(R4)+		;AND WE'RE OFF!

	IN GENERAL, THE COMPILER WILL HAVE TO MAINTAIN A SWITCH TELLING
	WHETHER POLISH MODE WAS IN EFFECT AT THE END OF THE PREVIOUS
	STATEMENT.  A VERY FEW STATEMENTS, SUCH AS CALL, WILL NORMALLY
	NOT RETURN TO POLISH MODE AND TWO CALLS IN A ROW SHOULD NOT
	REQUIRE A SPURIOUS ENTRY AND EXIT OF POLISH MODE.

4.8.10	TRANSFER OF CONTROL IS ACCOMPLISHED AS FOLLOWS:

	$TR:	MOV	@R4,R4		;DESTINATION TO R4
		JMP	@(R4)+		;AND GO

	THE SOURCE STATEMENT GOTO 10 GENERATES

		$TR,.10
						130-309-001-03
						PAGE 24

4.8.11	THE GENERAL DO STATEMENT

		DO 10 I=J,K,L

		...
	10	...

	CAN BE HANDLED BY

		....
		$P.J			;LOAD J
		$POP1,I 		;POP AN INTEGER, I=J
	$L:	...			;INTERNAL RETURN LABEL
		...
		$DOEND,L,I,K,$L 	;FIVE WORDS DOES IT!

	WHERE

	$DOEND: ADD	@(R4)+,@(R4)	;INCREMENT CONTROL VARIABLE
		CMP	@(R4)+,@(R4)+	;COMPARE TO LIMIT
		BGT	XY		;TEST FOR DONE
	$TR:	MOV	@R4,R4		;ONCE MORE PLEASE
		JMP	@(R4)+
	XY:	TST	(R4)+		;SKIP THE RETURN
		JMP	@(R4)+		;AND KEEP GOING

	NOTE THAT THE $TR IS CONTAINED IN $DOEND AND NEED NOT BE
	SEPARATELY GIVEN.

	HANDLING WHERE K AND/OR L ARE NOT SIMPLE VARIABLES HAS NOT
	BEEN WORKED OUT.  THIS IS NOT REQUIRED IN THIS FORTRAN.
						130-309-001-03
						PAGE 25

4.8.12	FINALLY WE COME TO THE HANDLING OF FORMAL PARAMETERS.  THE
	POLISH MODE STRING IS ESSENTIALLY THE SAME.  THE SERVICE
	SECTIONS LOOK LIKE THE FOLLOWING:

	;A IS FLOATING
	$P.A:	MOV	N(R5),R0	;GET THE ADDRESS FROM
					;CALLING SEQUENCE WHERE "N"
					;IS DEPENDANT ON POSITION IN
					;FORMAL LIST
		JMP	$PUT2		;NOW JUST LIKE BEFORE.

	THE ONE WORD AND FOUR WORD FORMS DIFFER ONLY IN WHICH $PUTX
	IS INVOKED.

	ASSIGNMENT TO A FORMAL PARAMETER IS:

	$POPP2: MOV	(R4)+,R3	;GET DISPLACEMENT OF
					;THIS FORMAL IN CALL
		ADD	R5,R3		;ADDRESS OF FORMAL ADDRESS
		MOV	@R3,R3		;ADDRESS OF THE PARAMETER
		JMP	POP2		;STORE TWO WORDS FROM STOCK

	SIMILARLY FOR ONE AND FOUR WORD DATA.  ASSIGNMENTS TO FORMALS
	ARE LIKE LOCAL ASSIGNMENTS EXCEPT THAT THE DISPLACEMENT IN
	THE CALL SEQUENCE TO THE ACTUAL ADDRESS MUST BE GIVEN TO THE
	SERVICE CODE INSTEAD OF THE BASE ADDRESS DIRECTLY.

4.8.13	ASSIGN

	[NOT YET AVAILABLE]


	THE PRECEEDING IS BELIEVED TO COVER THE MAJORITY OF CASES
	WHICH CAN OCCUR IN FORTRAN.  SOME ADDITIONAL STORAGE MAY
	BE SAVED IN THE PRECEEDING BY (CLEVERLY) COMBINING CODE,
	USING BR'S INSTEAD OF JMP'S, ETC.  BUT THE STRATEGY AND
	CLEANESS OF THE APPROACH SHOULD BE CLEARLY EVIDENT.
						130-309-001-03
						PAGE 26

4.9	DATA CONVENTIONS

4.9.1	INTEGER FORMAT

	AN INTEGER NUMBER IS A 16-BIT SIGNED QUANTITY.
	WHEN IN TWO WORD FORMAT, IT IS ASSIGNED TWO
	WORDS, WITH ONLY THE HIGH ORDER WORD BEING
	SIGNIFICANT.

4.9.2	REAL FORMAT

	THE REAL NUMBER FORMAT CONSISTS OF TWO WORDS OF DATA
	AS FOLLOWS:

		WORD N -   BIT 15    = SIGN OF MANTISSA
			   BITS 7-14 = BINARY EXCESS 128 EXPONENT
			   BITS 0-6  = HIGH ORDER MANTISSA

		WORD N+2 - BITS 0-15 = LOW ORDER MANTISSA

	THIS IS A SIGN-MAGNITUDE FORMAT WITH BINARY NORMALIZATION.

	THIS FORMAT IS LIMITED TO NORMALIZED NUMBERS AND THE HIGH
	ORDER BIT OF THE MANTISSA IS ALWAYS 1, THEREFORE THIS BIT
	IS DISCARDED IN THIS FORMAT GIVING AN EFFECTIVE PRECISION OF
	24 BITS.

4.9.3	DOUBLE PRECISION FORMAT

		WORD N - SAME AS 4.9.2
		WORD N+2 - SAME AS 4.9.2
		WORD N+4 - LOWER ORDER MANTISSA
		WORD N+6 - LOWEST ORDER MANTISSA

	THE EFFECTIVE PRECISION IS 56 BITS.
						130-309-001-03
						PAGE 27

4.9.4	COMPLEX FORMAT

		WORD N AND N+2	 - REAL PART (FORMAT AS IN 4.9.2)
		WORD N+4 AND N+6 - IMAGINARY PART (FORMAT AS IN 4.9.2)

4.9.5	BYTE FORMAT

	EACH DATA ITEM IN THIS FORMAT IS 8 BITS LONG.
	NO ARITHMETIC CAPABILITY EXISTS IN THIS MODE.

4.9.6	CHARACTER STRINGS

	A CHARACTER STRING IS DEFINED TO BE A STRING OF BYTE LENGTH
	ELEMENTS TERMINATED BY A ZERO BYTE.  THE LENGTH OF THIS
	FORM WILL BE LIMITED TO 255.

4.9.7	LOGICAL VALUES

	A LOGICAL VALUE AS REPRESENTED BY .TRUE. WILL BE
	EQUAL TO -1.  A LOGICAL VALUE AS REPRESENTED BY .FALSE.
	WILL BE EQUAL TO 0.

4.10	FILE CONVENTIONS

	[NOT YET AVAILABLE]
						130-309-001-03
						PAGE 28

5.0	DATA STRUCTURES

5.1	COMPILER DATA STRUCTURES

5.1.1	CORE STORAGE ALLOCATION

	EACH INTERNAL TABLE WILL INITIALLY BE ASSIGNED
	A BLOCK OF CORE STORAGE.  EACH BLOCK WILL BE MANAGED
	BY ITS OWN SET OF SPECIAL ROUTNES.  IN PHASE 1,
	OVERFLOW OF ANY BLOCK WILL RESULT IN AN ABORTED RUN.
	IN PHASE 2 A DYNAMIC ALLOCATION SCHEME WILL BE USED.
	ALL LINKS TO OTHER TABLE ENTRIES WILL BE RELATIVE TO
	THE START OF THE BLOCK CONTAINING THE ENTRY.

5.2 MAIN SYMBOL TABLE

	THE SYMBOL TABLE BLOCK WILL CONSIST OF A 64-WORD
	DIRECTORY AND THE ENTRIES THEMSELVES.  TO PUT AN ENTRY
	INTO THE TABLE, THE 6-CHARACTER SYMBOL IS HASHED INTO
	A 6-BIT NUMBER THAT POINTS TO A DIRECTORY WORD.  THE WORD
	POINTS TO THE FIRST ENTRY IN A CHAIN OF ENTRIES ALL OF
	WHOSE SYMBOLS HASHED TO THE SAME VALUE.

5.2.1 ENTRY FORMAT

	00  DATA ITEMS, INCLUDING ALL USER AND COMPILER
	    DEFINED VARIABLES AND LITERALS.

	01  STATEMENT FUNCTIONS.
	10  EXTERNAL FUNCTIONS.

5.2.1.0 WORD 0

 BITS 15-14  ENTRY TYPE: 00=DATA ITEM, INCLUDING ALL USER
		DEFINED VARIABLES AND LITERALS.
 BITS 13-11  DATA TYPE:
		000 LOGICAL-1
		001 LOGICAL-2
		010 INTEGER
		011 REAL
		100 DOUBLE PRECISION
		101 DOUBLE PRECISION
		101 COMPLEX
		110 HOLLERITH
		111 UNASSIGNED
	 BITS 10-9  DIMENSION
		00	NOT DIMENSIONED
		01-11	NUMBER OF DIMENSIONS

	BIT 8  CONSTANT BIT

	 BITS 7-0 LENGTH OF DATA ITEM IN BYTES(IF CONSTANT BIT=1)
		  PARAMETER LIST INDEX(IF CONSTANT BIT=0 AND PAR=1)
						130-309-001-03
						PAGE 29

5.2.1.1 WORD 1

	 BIT 15  COMMON INDICATOR (=1 IF ITEM IS IN COMMON)
		  NOTE: THIS INDICATOR AND THE PARAMETER INDICA-
		  TOR (5.2.1.1.5) WILL NEVER BOTH=1.

	 BIT 14  ADJUSTABLE ARRAY INDICATOR (=1 IF ITEM DEFINES AN
		  ADJUSTABLE ARRAY)

	 BIT 13  EQUIVALENCE INDICATOR (=1 IF ITEM APPEARED IN AN
		  EQUIVALENCE STATEMENT)
	 BIT 12  PARAMETER INDICATOR (=1 IF VARIABLE IS A PARAMETER
		  TO BE ACCESSED BY INDEXED ADDRESSING THROUGH R5)

		  NOTE: THIS INDICATOR AND THE COMMON INDICATOR (5.2.1.1)
		  WILL NEVER BOTH=1 SIMULTANEOUSLY.

	 BITS 11-0 SERIAL NUMBER

5.2.1.2 WORD 2: BITS 15-0  ADDRESS OF NEXT SYMBOL TABLE ENTRY. EQUAL TO 0 IF
		THIS IS THE LAST ENTRY IN THE TABLE.

5.2.1.3 WORD 3: BITS 15-0  1ST THREE CHARACTORS IN SYMBOL (RADIX 50)

5.2.1.4 WORD 4: BITS 15-0  NEXT THREE CHARACTERS IN SYMBOL

5.2.1.5 WORD 5
	BIT 15	SINGLE REFERENCE BIT
	BIT 14	ASSIGN BIT (USE IN ASSIGN STATEMENT)
	BIT 13	EXPLICIT BIT (EXPLICIT TYPING)
	BITS 12-0  UNUSED
						130-309-001-03
						PAGE 30

5.2.1.6 WORD 6: BITS 15-0  ADB POINTER.  POINTS TO THE ASSOCIATED
		ARRAY DESCRIPTOR BLOCK IF THIS ITEM IS DIMENSIONED
		(I.E., IF THE DIMENSION INDICATOR (5.2.1.0) IS NON-ZERO)

5.2.1.7 ADDITIONAL WORDS - VALUE OF ENTRY.
		PRESENT ONLY IF THE CONSTANT INDICATOR (5.2.1.0) IS A
		1.  THE VALUE WILL BE REPRESENTED AS THE BINARY EQUIVALENT
		OF THE ORIGINAL SOURCE NUMBER, OR AS STRING OF ASCII
		BYTES TERMINATED BY AT LEAST ONE BYTE = 0 IF THE THE ITEM
		IS A HOLLERITH CONSTANT.

		THE LENGTH OF THIS FIELD (INCLUDING TERMINATING ZEROS)
		IN BYTES IS CONTAINED IN THE DATA ITEM LENGTH(5.2.1.0).

5.3	COMMON TABLE.

	A SINGLE CONTIGUOUS AREA WILL BE USED TO ACCOMODATE IN-
	FORMATION COLLECTED FROM BOTH COMMON AND EQUIVALENCE
	STATEMENTS.  AFTER THE LAST DECLARATION STATEMENT IS
	PROCESSED IT WILL BE POSSIBLE TO PERFORM STORAGE ALLOCATION
	FOR ALL VARIABLES INVOLVED IN EITHER COMMON OR EQUIV-
	ALENCE WHEREUPON THE AREA USED CAN BE RECOVERED FOR OTHER
	USE BY THE COMPILER.

	WITHIN THIS AREA, COMMON WILL USE TWO DATA STRUCTURES:

5.3.1	COMMON BLOCK HEADER

	A 4 WORD ITEM:
		WORD 1 - LINK TO NEXT BLOCK HEADER (IF ANY)
		WORD 2 - FIRST THREE CHARACTERS OF BLOCK NAME (RADIX 50)
		WORD 3 - LAST THREE CHARACTERS OF BLOCK NAME
		WORD 4 - LINK TO VARIABLES FOUND IN THIS BLOCK.

5.3.2	COMMON BLOCK LIST

	A VARIABLE LENGTH BLOCK CONTAINING

	WORD 1 - LINK TO NEXT GROUP IN THIS NAMED BLOCK(IF ANY)
	WORD 2 - SERIAL NUMBER OF VARIABLES/ARRAYS
	WORD 2+N - "    "
	WORD 3+N - ZERO TERMINATOR.
						130-309-001-03
						PAGE 31

5.4	ARRAY DESCRIPTOR BLOCK TABLE (ADB)

	THIS TABLE HAS AN ENTRY FOR EACH ARRAY DEFINED IN THE SUBPROGRAM
	BEING COMPILED.  THE ADB IS AVAILABLE TO THE COMPILER SO THAT IT
	MAY COMPUTE AND FIX ARRAY ENTRY REFERENCES WHEN THE SUBSCRIPTS
	ARE CONSTANTS, AND SO THAT IT MAY RESERVE THE APPROPRIATE AMOUNT
	OF MEMORY FOR EACH ARRAY DURING "END" PROCESSING.  THE FORMAT OF
	THE COMPILE TIME AND THE OBJECT TIME ADB'S ARE NOT THE SAME.
	SEE ALSO 130-309-001, SECTION 3.1.2.6.

5.4.1.0 WORD 0:   LINK TO NEXT ADB (=0 IF THIS IS THE LAST ADB).

5.4.1.1 WORD 1
	 BITS 15-14 NUMBER OF DIMENSIONS IN THIS ARRAY
	 BITS 13-11 DATA TYPE (SEE SECTION 5.2.1.0)
	 BITS 7-0 SIZE IN BYTES OF A DATA ELEMENT.

5.4.1.2 WORD 2: NUMBER OF INDEX ITEMS, FIRST DIMENSION

5.4.1.3 WORD 3: NUMBER OF INDEX ITEMS, 2ND DIMENSION

5.4.1.4 WORD 4: NUMBER OF INDEX ITEMS, 3RD DIMENSION

5.4.2	WORDS 4 AND 3, OR JUST WORD 3, ARE PRESENT FOR 3 DIMENSIONAL AND
	FOR 2 DIMENSIONAL ARRAYS, RESPECTIVELY.  IF ANY DIMENSION IS
	ADJUSTABLE, THE CORRESPONDING INDEX ITEM WORD WILL CONTAIN A
	ZERO.
						130-309-001-03
						PAGE 32

5.5	EQUIVALENCE BLOCK

	A BLOCK IS CREATED FOR EACH GROUP OF ITEMS WHICH ARE
	EQUIVALENCED TO EACH OTHER.  FORMAT IS:

		WORD 1,2 - A TWO WORD WIRK AREA FOR THIS GROUP
		WORD 3 - LINK TO NEXT GROUP(IF ANY)
		WORD 3+N - SERIAL NUMBER OF N-TH ITEM IN THIS GROUP
		WORD	4+N - TOTAL OFFSET(IN BYTES) OF ITEM IN
			THIS GROUP FROM THE BASE OF THE ITEMS AS
			DEFINED
		WORD M - ZERO TERMINATOR.

5.6	IMPLICIT TABLE

	A 26(10) BYTE TABLE WHCIH RELATES LETTERS OF THE ALPHABET TO
	THE VARIABLE TYPE-MODES TO BE SELECTED WHENEVER IMPLICIT MODE
	ASSIGNMENT IS CALLED FOR.

	IF THE FIRST CHARACTER OF A SYMBOL HAS OCTAL REPRESENTATION
	N, THE ENTRY AT RELATIVE BYTE POSITION N-1 CONTAINS THE MODE
	TO BE IMPLICITLY USED FOR THAT SYMBOL.

5.7	DO TABLE

	CREATED UPON PROCESSING OF A DO STATEMENT (SEE SECTION 7.2.21).

5.7.1.0 WORDS 0,1,2 SYMBOL STATEMENT NUMBER OF TERMINAL STATEMENT.

	(WORD 0=-1 IF THIS ENTRY IS INACTIVE).
	(WORD 0= 0 IF THIS ENTRY IS FOR AN IMPLIED DO).

5.7.1.3 WORDS 3,4,5 SYMBOL: DESTINATION OF RETURN JUMP.

5.7.1.6 WORD 6 POINTER TO CONTROL VARIABLE SYMBOL TABLE ENTRY

5.7.1.7 WORD 7 POINTER TO INITIAL PARAMETER SYMBOL TABLE ENTRY

5.7.1.8 WORD 8 POINTER TO TERMINAL PARAMETER SYMBOL TABLE ENTRY

5.7.1.9 WORD 9 POINTER TO INCREMENTATION PARAMETER SYMBOL TABLE ENTRY

5.7.1.10 WORD 10 POINTER TO (SOMETHING)

5.7.1.11 WORD 11 LINK TO PREVIOUS DO ENTRY (=0 IF THIS IS THE FIRST ENTRY).

5.7.1.12 WORD 12 LINK TO NEXT DO ENTRY (=0 IF THIS IS THE LAST ENTRY).
						130-309-001-03
						PAGE 33

5.8	OBJECT TIME DATA STRUCTURES

	SEE 130-311-001 (15 NOV 70, EST.)
	    130-312-015 (15 NOV 70, EST.)
	    130-313-001 (15 NOV 70, EST.)

6.0	INPUT/OUTPUT

6.1	COMPILER I/O

	[NOT YET AVAILABLE]

6.2	OBJECT TIME I/O

	SEE 130-311-001 (15 NOV 70, EST.)
	    130-313-001 (15 NOV 70, EST.)

6.3	DIAGNOSTIC OUTPUT

	A FORTRAN SOURCE DIAGNOSTIC WILL CONSIST OF THE FOLLOWING:

	<XXXXXYXXXXX> ERROR ZZZ - MESSAGE.

	IMMEDIATELY FOLLOWING THE LINE IN ERROR.  5 CHARACTERS
	(XXXXX) ON EITHER SIDE OF THE CURRENT CHARACTER POSITION
	(Y) WILL BE PRINTED (WITH CONTROL CHARACTERS INTERPRETED
	ALSO) INSIDE THE BRACKETS, FOLLOWED BY THE ERROR NUMBER
	(ZZZ), AND THE TEXT OF THE MESSAGE (IF ANY) CORRESPONDING
	TO THE ERROR NUMBER AS FOUND IN THE DISK ERROR DIRECTORY.
	THE MESSAGE MAY BE ANY ASCII STRING TERMINATED BY A ZERO
	BYTE.

	ALL ERROR DIAGNOSTICS WILL BE PRINTED ON THE SOURCE
	LISTING AND WILL ALSO BE PLACED AS A COMMENT IN
	THE  OBJECT FILE.  IF NO SOURCE LISTING IS BEING PRINTED,
	THE DIAGNOSTIC WILL BE PRINTED ON THE CONSOLE TELETYPE.
						130-309-001-03
						PAGE 34
7.0	LANGUAGE

7.1	SOURCE LANGUAGE

	ITEMS IMPLEMENTED FOR 1130 COMPATIBLIITY ARE TAGGED
	"1130".

7.1.1	LANGUAGE EXCEPTIONS AND DIFFERENCES FROM ANSI FORTRAN IV.

	THE FOLLOWING ARE KEYED TO THE CORRESPONDING SECTION
	NUMBERS IN THE ANSI FORTRAN IV SPECIFICATION.

	<3.2> LINE FORMATS.

	A TAB MAY BE USED IN LIEU OF MULTIPLE SPACES AT THE
	START OF A LINE.  IF A NUMERIC CHARACTER FOLLOWS THE
	TAB, A CONTINUATION IS ASSUMED.

	NO MORE THAN FIVE CONTINUATIONS WILL BE ALLOWED.

	<4.2> DATA TYPES.

	INTEGERS ARE 16 BIT SIGNED NUMBERS.  THEY ARE NORMALLY STORED
	IN A TWO WORD FORMAT WHERE THE FIRST WORD IS THE VALUE
	AND THE SECOND IS A FILLER WORD.  SINGLE WORD INTEGERS
	MAY BE SELECTED AS DESCRIBED IN SECTION 3.2.

	REAL NUMBERS USE A TWO WORD FORMAT AS DESCRIBED IN
	SECTION 4.9.2.

	DOUBLE PRECISION USES A FOUR WORD FORMAT(SECTION 4.9.3).

	COMPLEX USES A FOUR WORD FORMAT(SECTION 4.9.4).

	LOGICAL*1 IS A SPECIAL ONE BYTE FORMAT USED ONLY FOR
	ALPHANUMERIC MANIPULATIONS.  NO ARITHMETIC
	MANIPULATIONS ARE ALLOWED IN THIS MODE(SECTION 4.9.5).

	<5.1.1> CONSTANTS.

	HEX AND OCTAL CONSTANTS WILL BE ALLOWED WITHIN DATA
	STATEMENTS.  THE FORMATS ARE:

		ZNNNN	FOR A HEX CONSTANT(1130)
		ONNNN	FOR AN OCTAL CONSTANT

	WHERE NNNN IS THE HEX OR OCTAL VALUE RESPECTIVELY.  NOTE
	THAT HEX VALUES MAY NOT EXCEED FFFF AND OCTAL VALUES MAY
	NOT EXCEED 177777.

	AN ALTERNATE FORM OF HOLLERITH CONSTANT IS A STRING OF
	CHARACTERS SURROUNDED BY SINGLE QUOTES.  WITHIN THE STRING,
	A DOUBLE QUOTE DENOTES A SINGLE QUOTE IN THE STRING.  DOUBLE
	QUOTE CAN NOT BE REPRESENTED IN A STRING DEFINED VIA SINGLE
	QUOTES.
						130-309-001-03
						PAGE 35

	<6.1> ARITHMETIC EXPRESSIONS

	GENERAL MIXED MODE EXPRESSIONS ARE ALLOWED.

	THE FORM A**B**C IS LEGAL AND HAS THE SPECIAL CASE
	EVALUATION OF A**(B**C) TO CONFORM WITH USUAL PRACTICE.

	<7.1.2.1.2> ASSIGNED GOTO

	THE LABEL LIST IS OPTIONAL.  A COMPILER DIAGNOSTIC
	WILL BE SUPPLIED IF THE VARIABLE IS ALSO USED IN AN
	EXPRESSION.

	<7.1.2.1.3> COMPUTED GOTO

	WHEN THE VALUE OF THE EXPRESSIN FALLS OUTSIDE THE RANGE
	OF THE SUPPLIED STATEMENTS, AN OBJECT TIME ERROR
	DIAGNOSTIC WILL BE ISSUED.

	<7.1.2.7> STOP N AND PAUSE N.

	N MAY BE ANY OF THE FOLLOWING:

		1.  A ONE TO SIX DIGIT OCTAL CONSTANT (NOT LARGER
		    THAN 177777).
		2.  A ONE TO FOUR DIGIT HEX CONSTANT PRECEDED BY
		    A Z(NOT LARGER THAN FFFF)(1130).
		3.  ANY CHARACTER STRING DELIMITED BY QUOTE MARKS.

	THE VALUE OR STRING WILL BE TYPED ON THE TELEPRINTER
	WHEN THE STOP OR PAUSE IS EXECUTED.

	<7.1.2.8> DO STATEMENT.

	INTEGER VARIABLES OR CONSTANTS MAY BE USED FOR THE DO
	PARAMETERS(1130).

	<7.1.3> I/O STATEMENTS.

	THE FOLLOWING STATEMENTS ARE ADDED TO FACILITATE RANDOM
	ACCESS I/O TO A FIXED OR MOVING HEAD DISK(1130).

	A)	DEFINE FILE A(M,L,U,V)

		SET UP A FILE AS FOLLOWS:

		A - SYMBOLIC FILE DESIGNATOR (AN INTEGER CONSTANT
		    FROM 1 TO 32767). THIS IS THE DESCRIPTOR BY
		    WHICH THE FILE IS RECOGNIZED WHEN A FIND, READ
		    OR WRITE IS EXECUTED.
		M - MAXIMUM NUMBER OF RECORDS IN THE FILE.
		L - LENGTH OF EACH RECORD IN WORDS.
		U - THE LETTER "U" WHICH DECLARES THE FILE TO
		    BE UNFORMATTED (E.G. - BINARY).  NO OTHER DES-
		    IGNATION IS LEGAL.
		V - ASSOCIATED VARIABLE NAME TO BE USED FOR THE
		    RECORD POINTER.
						130-309-001-03
						PAGE 36

	B)	FIND (A'B)

		POSITION THE DISK HEAD PROPERLY FOR RECORD #B OF FILE
		#A.  THIS IS A NO-OPERATION COMMAND FOR A FIXED HEAD
		DISK.  "A" REFERS TO THE SYMBOLIC FILE DESIGNATOR AND
		IS DESCRIBED IN SECTION (A) ABOVE.  "B" IS A SIMPLE INTEGER
		VARIABLE OR CONSTANT NOT GREATER THAN 32767.

	C)	READ (A'B) LIST
		WRITE (A'B) LIST

		READ OR WRITE THE B-TH RECORD OF FILE A.
		"A" AND "B" ARE AS DESCRIBED ABOVE.

	AN I/O STATEMENT MAY OPTIONALLY SPECIFY END-OF-FILE AND/OR
	ERROR CONDITIONS AS SHOWN IN THIS EXAMPLE:

		READ (1,100,END=10,ERR=20)LIST

	WHERE END=10 SPECIFIES STATEMENT 10 FOR END-OF-FILE
	PROCESSING AND ERR=20 SPECIFIES STATEMENT 20 FOR ERROR
	PROCESSING.

	<7.2.1> SPECIFICATION STATEMENTS.

	ALTERNATE FORMS OF TYPE STATEMENTS MAY BE AS FOLLOWS(1130):

		BYTE = LOGICAL*1
		INTEGER = INTEGER*2
		REAL = REAL*4
		DOUBLE = REAL*8

	AN "IMPLICIT" TYPE STATEMENT IS ALSO ALLOWED.  IT CAUSES
	ALL VARIABLES BEGINNING WITH SOME SPECIFIED LETTER TO BE CON-
	SIDERED AS A GIVEN TYPE, UNLESS EXPLICITLY STATED OTHERWISE.

		EXAMPLE:

		IMPLICIT REAL*4 (M-P,R)
		INTEGER MRR

	CAUSES VARIABLE MRR TO BE AN INTEGER, WHILE ALL OTHER
	VARIABLES BEGINNING WITH M-P AND R ARE TREATED AS REAL.

		E.G. - STANDARD FORTRAN WOULD IMPLY:

			IMPLICIT REAL*4 (A-H,O-Z)
			IMPLICIT INTEGER*2 (I-N)

	<7.2.3> FORMATS.

	THE "O" (OCTAL) FIELD SPECIFICATION IS ALLOWED.

	THE "T" (TAB) SPECIFICATION IS ALLOWED.

	AN ALTERNATE FORM OF THE H SPECIFICATION IS A
	STRING OF CHARACTERS SURROUNDED BY SINGLE QUOTES.

						130-309-001-03
						PAGE 37

7.2	OBJECT LANGUAGE OUTPUT

7.2.1	SUBROUTINE, FUNCTION STATEMENTS

	THE SUBROUTINE AND FUNCTION STATEMENTS CAUSE INTERNAL FLAGS
	AND COUNTERS TO BE SET DESCRIBING:

	A)  THE NUMBER OF PARAMETERS AND THEIR POSITION
	B)  WHETHER THIS IS A FUNCTION OR A SUBROUTINE
	C)  THE ROUTINE NAME AND TYPE

	A NON-FATAL DIAGNOSTIC IS GIVEN IF THE STATEMENT HAS A LINE
	NUMBER.

	THE OUTPUT GENERATED IS:

		.TITLE	XXX
		.CSECT
	R0	=	%0
	R1	=	%1
	R2	=	%2
	R3	=	%3
	R4	=	%4
	R5	=	%5
	SP	=	%6
	PC	=	%7
		.GLOBL	XXX
	XXX:

	WHERE XXX IS THE NAME OF THE ROUTINE.  A MAIN PROGRAM IS
	HANDLED IN THE SAME FASHION, EXCEPT THAT THE ROUTINE NAME
	IS DEFINED TO BE "MAIN.".

7.2.2	ENTRY STATEMENT

	A) MAKES SURE THE ROUTINE NAME HAS NOT BEEN PREVIOUSLY
	   USED IN AN ENTRY, EXTERNAL, OR OTHER DECLARATIVE STATEMENT.
	B) DOESN'T ALLOW A LINE NUMBER.

	THE OUTPUT GENERATED IS:

		.GLOBL	XXX
	XXX:

	WHERE XXX IS THE ENTRY NAME.
						130						130-309-001-03
						PAGE 38

7.2.3	EXTERNAL STATEMENT

	A) ROUTINE NAME CANNOT HAVE BEEN PREVIOUSLY DEFINED.
	B) DOESN'T ALLOW A LINE NUMBER.

	THE OUTPUT GENERATED IS:

		.GLOBL	XXX

	WHERE XXX IS THE EXTERNAL NAME.  NOTE THAT THE ONLY DIFFERENCE
	FROM ENTRY IS THAT NO LABEL IS GENERATED.

7.2.4	CALL

	CALL XXX(X1,X2,X3,...XN) COMPILES AS:

		.GLOBL	XXX
		JSR	R5,XXX
		BR	$FNNNN
		X1
		X2
		.
		.
		.
		XN
	$FNNNN:

	WHERE XXX IS THE NAME OF THE SUBROUTINE TO BE CALLED AND
	X1, X2, ... XN ARE THE ARGUMENTS OF THE LIST.

7.2.5	RETURN

	GENERATES:

		RTS	R5

7.2.6	GOTO

	GENERATES:

		$TR,.XXX

	WHERE XXX IS THE STATEMENT NUMBER IN QUESTION AND $TR
	IS A POLISH MODE JUMP(SEE SECTION 4.8.10).

	EXAMPLE:

		GOTO 237

		WOULD GENERATE:

		$TR,.237
						130-309-001-03
						PAGE 39

7.2.7	ASSIGN

	ASSIGN 15 TO I WOULD GENERATE

		$AS,.15,I

	WHEN THIS STATEMENT IS ENCOUNTERED, A FLAG IS SET TO DISALLOW
	USING THE VARIABLE ASSIGNED AS A PARAMETER IN A CALL
	STATEMENT(OR FUNCTION CALL) AND TO DISALLOW ITS USE IN
	ARITHMETIC CALCULATIONS(SEE SECTION 4.8.13).

7.2.8	CONTINUE

	GENERATES NO CODE!!

7.2.9	PAUSE XXX

	GENERATES:

		.GLOBL	$PAUSE
		$PAUSE,X

	WHERE X IS THE ADDRESS OF THE STRING TO BE PRINTED ON THE
	CONSOLE.

7.2.10	STOP

	GENERATES:

		.GLOBL	$STOP
		$STOP,X

	WHERE X IS THE ADDRESS OF THE STRING TO BE PRINTED ON THE
	CONSOLE.

7.2.11	FORMAT

	10	FORMAT (XXXX)  WOULD COMPLE AS:

		$TR,$FNNNN
	$10:	.ASCII	^(XXXX)^
		.EVEN
	$FNNNN:

	WHERE XXXX IS THE CONTENTS OF THE FORMAT STATEMENT.
						130-309-001-03
						PAGE 40

7.2.12	ENDFILE

	WOULD GENERATE:

		.GLOBL	$ENDFL
		$P.N
		$ENDFL

	WHERE N IS THE ADDRESS OF THE DESIRED UNIT NUMBER.

7.2.13	REWIND

	AS IN 7.2.12 EXCEPT USE THE ROUTINE "$RWIND".

7.2.14	BACKSPACE

	AS IN 7.2.12 EXCEPT USE THE ROUTINE "$BCKSP".

7.2.15	END

	GENERATES A "RETURN" FOLLOWED BY ALL CONSTANTS, DATA,
	AND VARIABLES FOR THE ROUTINE FOLLOWED BY A .END STATEMENT.

	IN A MAIN PROGRAM, A:

		.GLOBL	$EXIT
		$EXIT

	IS GENERATED INSTEAD OF A "RETURN".
						130-309-001-03
						PAGE 41

7.2.16	TYPE STATEMENTS

	THIS ROUTINE WILL HAVE SEVERAL ENTRIES, ONE EACH FOR INTEGER,
	REAL, ETC.

	THE TYPE PROCESSOR WILL MAKE SYMBOL TABLE ENTRIES FOR EACH VARIABLE
	NOT ALREADY IN THE SYMBOL TABLE, AND WILL SET FIELDS & INDICATORS
	AS FOLLOWS:

		DATA TYPE
		DIMENSION (IF SPECIFIED BY PARENTHESES)
		LENGTH OF ITEM
		ADJUSTABLE ARRAY (IF A VARIABLE APPEARS BETWEEN
				   PARENTHESES)
		SYMBOL

	"DIMENSION" AND "ADJUSTABLE ARRAY" USE CODING IN THE
	DIMENSION PROCESSOR.

7.2.17	DIMENSION STATEMENTS

	THIS PROCESSOR MAKES SYMBOL TABLE ENTRIES FOR EACH VARIABLE
	NOT ALREADY IN THE SYMBOL TABLE, AND SETS SYMBOL TABLE FIELDS
	AS FOLLOWS:

		DATA TYPE (IMPLICIT DEFINITION IF NOT ALREADY DEFINED)
		DIMENSION
		LENGTH OF DATA ITEM (IMPLICIT IF NOT ALREADY DEFINED)
		ADJUSTABLE ARRAY
		SYMBOL

	THE "END" PROCESSOR WILL OUTPUT TO THE ASSEMBLER ALL THE ADB'S IN
	OBJECT-TIME FORMAT (SEE 130-309-001, SECTION 3.1.2.6) AND WILL
	RESERVE SPACE FOR ALL ARRAYS.

	ANY ADB ANY OF WHOSE DIMENSION SIZES ARE =-1 WILL INDICATE AN
	ERROR IN THE DEFINITION OF THE ARRAY (SEE SECTION 7.2.20).
						130-309-001-03
						PAGE 42

7.2.18	COMMON

	EACH LIST ITEM IS PLACED IN THE MAIN SYMBOL TABLE (IF IT IS NOT
	ALREADY THERE) AND, IF DIMENSIONS ARE SPECIFIED, APPROPRIATE
	ADB ITEMS ARE PRODUCED (SEE SECTION 7.2.17).

	THE DEFINITIONS WILL BE MADE VIA THE "=" OPERATOR IN PAL-11R
	AND WILL BE RELATIVE TO THE BASE OF THE APPROPRIATELY
	NAMED CSECT.
						130-309-001-03
						PAGE 43

7.2.19	    EQUIVALENCE

7.2.19.1   THE GENERAL FORM OF THE EQUIVALENCE STATEMENT IS:

		EQUIVALENCE (A1(I1),A2(I2)...AN(IN),(B1(J1),...),...

	    WHERE THE "A" TERMS ARE EQUIVALENCED TO EACH OTHER, THE
	    "B" TERMS ARE EQUIVALENCED TO EACH OTHER, ETC.

	    THE "A" TERMS ARE ARRAY IDENTIFIERS OR SINGLE VARIABLES.
	    FOR ARRAY IDENTIFIERS THE "I" TERMS ARE CONSTANT SUBSCRIPTS.
	    THE COMPILER REQUIRES THE BYTE POSITION OF EACH ITEM IN THE
	    EQUIVALENCE LIST, AND WILL THEREFORE REPLACE THE "I" TERM
	    BY THE EQUIVALENT "INDEX VALUE" OF THE ITEM.  THE INDEX
	    VALUE IS THE ADDRESS OF THE ITEM RELATIVE TO THE START OF
	    THE ARRAY IS COMPUTED JUST AS AT OBJECT TIME (SEE F309VX.SPC,
	    SECTION 3.1.2.6).

	    IF A TERM IS A SINGLE VARIABLE, THE I TERM WILL NOT APPEAR
	    IN THE SOURCE, AND THE COMPILER WILL TAKE IT TO BE 0.

	    IN WHAT FOLLOWS THE SYMBOLS I, I1, ..., IM, ETC., INDICATE
	    "INDEX VALUES".  WE THEN DEFINE THE "OFSET" OF AK:

		OFFSET AK = MAX(IM) - IK

	    WHERE I1, I2, ..., IM NOW DENOTE THE INDEX VALUES OF THE
	    ITEMS, WE CAN THEN SAY THAT:

		AK(1) IS EQUIVALENT TO AI (OFFSET(AK))

	    WHERE THE SUBSCRIPT I HAS BEEN CHOSEN SUCH THAT IT=MAX(IM).
	    THIS PROVIDES AN EQUIVALENCE BETWEEN THE START OF EACH
	    ARRAY AND SOME RELATIVE BYTE POSITION WITHIN ONE OF THE
	    ARRAYS, NAMELY THE ARRAY AI.

	    THE ACTUAL EQUIVALENCING WOULD TAKE INTO ACCOUNT THE
	    SIZE OF AN ENTRY IN AI.

7.2.19.2   WHEN THE COMPILER ENCOUNTERS AN EQUIVALENCE STATEMENT THE
	    FOLLOWING ACTIONS WILL BE TAKEN:

	  A SYMBOL TABLE ENTRY WILL BE LOCATED OR CONSTRUCTED FOR
	    EACH ITEM IN THE STRING, AND THE EQUIVALENCE BIT WILL BE
	    SET (SECTION 5.2.1.1).
						130-309-001-03
						PAGE 44

	  AN "EQUIVALENCE BLOCK" FOR EACH SET OF EQUIVALENCED ITEMS
	    WILL BE ESTABLISHED.  THE FORMAT OF THE EQUIVALENCE BLOCK
	    IS DEFIN SECTION 5.6.

7.2.19.3    WHEN THE "END" STATEMENT IS ENCOUNTERED, CODE WILL BE
	    GENERATED TO RESERVE SPACE FOR ALL NON-EQUIVALENCED
	    VARIABLES.	THEN ALL EQUIVALENCE CHAINS WILL BE RESOLVED
	    BY MEANS OF THE EQUIVALANCE BLOCKS, USING AN ALGORITHM
	    SIMILAR TO THAT DESCRIBED IN ARDEN, GALLER AND GRAHAM,
	    "AN ALGORITHM FOR EQUIVALENCE DECLARATIONS", ACM COMM.,
	    VOL 4, NO. 7.

7.2.20	DATA STATEMENTS DATA K1/D1/,K2/D2/,...

	PROCESSING OF THIS STATEMENT ASSUMES THAT NO CONTRADICTORY
	TYPING OF THE VARIABLES IN THE STATEMENT WILL OCCUR AFTERWARDS.

	AS WITH THE DIMENSION AND COMMON PROCESSORS, THE VARIABLES IN
	EACH LIST K ARE ENTERED INTO SYMBOL TABLE IF THEY ARE NOT ALREADY
	THERE (REFERENCES TO ARRAY ELEMENTS WITH FIXED SUBSCRIPTS WILL
	CAUSE ARRAYS TO BE DEFINED WITH ALL DIMENSION SIZES=-1).
	IN ADDITION, A TEMPORARY LIST WILL BE CONSTRUCTED CONSISTING OF
	POINTERS INTO THE SYMBOL TABLE, ONE FOR EACH LIST ITEM.

	THE CONSTANT DATA FOLLOWING THE SLASH WILL THEN BE MATCHED TO THE
	LIST ITEMS AND ORIGINED APPROPRIATELY.
						130-309-001-03
						PAGE 45

7.2.21	DO 10 I=J,K,L

	COMPILES AS FOLLOWS:

	A.  $P.J	;PUSH J
	    $POP1,I	;POP TO I
	$L:
	B.  A "DO TABLE" ENTRY IS CONSTRUCTED UPON ENCOUNTERING THE DO
	    STATEMENT (SEE SECTION 5.7).  THE "RETURN JUMP" DESTINATION
	    IS THE LABEL GENERATED FOLLOWING THE MOV IN SECTION 7.2.21.A ABOVE.
	C.  IF THERE ARE ANY ENTRIES ACTIVE (SEE SECTION 5.7.1.0) IN
	    THE DO TABLE, IT IS SEARCHED AFTER THE CODE FOR EACH LABELLED
	    STATEMENT IS GENERATED.  WHEN A MATCH BETWEEN STATEMENT
	    LABEL AND TERMINAL STATEMENT LABEL OCCURS, TWO POSSIBILITIES
	    EXIST:

	    C.1  THE CORRESPONDING DO TABLE ENTRY IS NOT THE LAST ACTIVE
		 ENTRY IN THE TABLE - IN THIS CASE THE DO'S ARE NOT PROPERLY
		 NESTED.
	    C.2  THE CORRESPONDING DO TABLE ENTRY IS THE LAST ACTIVE
		 ENTRY IN THE TABLE - IN THIS CASE THE FOLLOWING CODE
		 IS GENERATED:

			$DOEND,L,I,K,$L

		(SEE 130-309-001, 4.8.11)

7.2.22	IF

7.2.22.1	LOGICAL IF

	THE EXPRESSION WITHIN THE PARENTHESES REDUCES TO THE COMPARISON
	OF TWO TERMS (EACH OF WHICH MAY BE A LOGICAL EXPRESSION).

	CODE IS GENERATED TO EVALUATE THESE TERMS AND PLACE THE RESULTS
	IN TEMPORARIES.  THE TWO TEMPORARIES ARE SENT TO THE OTS "LOGICAL
	IF" ROUTINE WHICH RETURNS WITH THE RESULT OF THE COMPARISON IN
	THE CONDITION CODES.  THE CODES ARE TESTED WITH THE CONDITIONAL
	BRANCH THAT CORRESPONDS TO THE SOURCE STATEMENT LOGICAL OPERATOR
	WHICH CONNECTED THE TWO TERMS.	SEE SECTION 3.1.2.2.

7.2.22.2	ARITHMETIC IF

	THE EXPRESSION WITHIN THE OUTER PARENTHESES IS EVALUATED AND
	THE RESULT IS PASSED TO THE OTS "ARITHMETIC IF" ROUTINE.  IT
	RETURNS INDIRECTLY TO ONE OF THE THREE LOCATIONS FOLLOWING THE
	CALLING SEQUENCE.  SEE SECTION 3.1.2.2.
						130-309-001-03
						PAGE 46

7.2.23	READ, WRITE

	OBJECT CODE FOR READS AND WRITES IS HANDLED IN A UNIFORM MANNER,
	AND IS BASED ON THE USE OF AN "INITIALIZE" CALL, SEVERAL READS
	OR WRITES TO TRANSMIT LIST ITEMS TO THE OTS ROUTINES, AND AN
	"END" CALL WHEN THE LIST IS DEPLETED (SEE 130-309-001, SECTION 3.1.2.4).

	THE METHOD FOR GENERATING CODE FOR A TYPICAL FORMATTED READ IS
	GIVEN AS AN EXAMPLE:

7.2.23.1 EXAMPLE:	READ (M,100)A,B,(X(I),I=J,K,L)

	A.  UPON ENCOUNTERING THE FIRST RIGHT PARENTHESIS, THE COMPILER
	    GENERATES THE INITIALIZATION CALL:

			$P.M
			$P.100
			$INFI,0,0

	B.  IF THE NEXT ITEM IN THE STATEMENT IS NOT A LEFT PARENTHESIS,
	    THE COMPILER PUTS A POINTER TO EACH LIST ITEM INTO THE
	    READ CALLING SEQUENCE, UNTIL A LEFT PARENTHESIS OR
	    END OF STATEMENT IS FOUND:

			$P.A
			$P.B
			$P.2
			$IOR

	C.  WHEN A LEFT PARENTHESIS IS ENCOUNTERED THE COMPILER LOOKS
	    AHEAD FOR THE IMPLIED DO PARAMETERS, GENERATES A LABEL
	    FOR THE DO RETURN JUMP DESTINATION ($F0002 IN THIS
	    EXAMPLE) AND MAKES AN ENTRY IN THE DO TABLE FOR AN
	    IMPLIED DO-LOOP.

	    THE DO PROCESSOR IS USED TO GENERATE THE LOOP
	    INITIALIZATION:

			$P.J
			$POP1,I

	D.  THE LIST ITEMS ARE THEN PASSED TO THE READ ROUTINE AS
	    IN PART B (EXCEPT THAT A SUBSCRIPTED ITEM NOW APPEARS IN
	    THE LIST)

		$F0002: <CALL TO SUBSCRIPT ROUTINE FOR X(I)>
			$PSHR1	;PUSH REGISTER ON STACK
			$P.1
			$IOR
						130-309-001-03
						PAGE 47

	E.  WHEN THE DO CONTROL VARIABLES ARE ENCOUNTERED IN THE
	    LIST THEY ARE SCANNED OVER UNTIL A RIGHT PARENTHESIS IS
	    FOUND.  THE RIGHT PARENTHESIS TRIGGERS A CALL TO THE DO
	    PROCESSOR TO GENERATE LOOPING INSTRUCTIONS FROM INFORMATION
	    ON TOP OF THE DO TABLE STACK:

			$DOEND,L,I,K,$F0002

	F.  THE DO LOOP FINALLY FALLS THROUGH FOR TRANSMISSION
	    OF THE NEXT LIST ITEM; IN THIS CASE THERE ARE NO MORE
	    ITEMS SO THE COMPILER GENERATES CODE TO TERMINATE
	    THE OPERATION:

			$IOF

7.2.24	DEFINE FILE A(M,L,U,V)

	SEE SECTION 7.1.3.  THE GENERATED CODE WILL BE:

		[TO BE DETERMINED]

7.2.25	FIND (U'B)

	SEE SECTION 7.1.3.  THE GENERATED CODE WILL BE:

		[TO BE DETERMINED]

7.2.26	IMPLICIT

	THE COMPILER WILL MAINTAIN A TABLE FROM WHICH ALL IMPLICIT
	DEFINITIONS OF VARIABLES ARE MADE (SEE SECTION 5.6).

	THIS ROUTINE WILL ADJUST ENTRIES IN THE TABLE ACCORDING TO THE
	INTENT OF THE IMPLICIT STATEMENT.

7.2.27	BLOCK DATA

	WHEN THIS STATEMENT IS ENCOUNTERED THE COMPILER SETS THE
	BLOCK DATA SWITCH, TO BE TESTED WHENEVER AN EXECUTABLE IS EN-
	COUNTERED IN THE SOURCE PROGRAM (AN ERROR).
						130-309-001-03
						PAGE 48

7.3	OBJECT TIME SYSTEM EXCEPTIONS AND DIFFERENCES FROM ANSI FORTRAN.

7.3.1	LIBRARY

	THE FOLLOWING FORTRAN LIBRARY ROUTINES WILL BE ADDED TO
	THE ANSI LIST:

	1.  DATE - RETURNS THE CURRENT DATE.
	2.  TIME - RETURNS THE CURRENT TIME OF DAY.
	3.  SSWTCH - RETURNS THE CONTENTS OF THE SWITCH REGISTER.
	4.  ASIN - ARCSINE
	5.  COT - COTANGENT
	6.  RAN - RANDOM NUMBER GENERATOR
	7.  TAN - TANGENT
	8.  PDUMP - DUMP CORE BETWEEN SPECIFIED LIMITS
	9.  EXIT - TERMINATE PROGRAM.

7.3.2	COMPLEX FACILITIES

	THE FOLLOWING COMPLEX ROUTINES WILL BE DEFERRED FOR LATER
	IMPLEMENTATION IN THE OBJECT TIME SYSTEM.

	1.  REAL
	2.  AIMAG
	3.  CONJG
	4.  CEXP
	5.  CLOG
	6.  CSIN
	7.  CCOS
	8.  CSQRT
	9.  CABS
	10. CATAN

	ALL COMPLEX ARITHMETIC HANDLERS WILL ALSO BE DEFERRED.

7.3.3	FORTRAN OVERLAYS

	THE INITIAL RELEASE WILL NOT HAVE FACILITIES FOR OVERLAYING
	PROGRAMS.

	FUTURE FORTRAN CALLABLE OVERLAY PROVISIONS
	("CALL CHAIN" OR "CALL LINK")MUST BE CONSIDERED.

7.3.4	RANDOM ACCESS I/O

	[NOT YET AVAILABLE]
						130-309-001-03
						PAGE 49


8.0	COMMAND LANGUAGE AND STRUCTURE

	[NOT YET AVAILABLE]

9.0	OPERATING PROCEDURES

	[NOT YET AVAILABLE]

10.0	PHYSICAL DESCRIPTION AND ORGANIZATION

	SEE	130-311-001
		130-312-015
		130-313-001

11.0	FUNCTIONAL DESCRIPTION AND OPERATION

	SEE	130-311-001
		130-312-015
		130-313-001

12.0	PROGRAMMING CONSIDERATIONS

	[NOT YET AVAILABLE]

13.0	PREPARATION AND/OR SYSTEM BUILD

	[NOT YET AVAILABLE]

14.0	MAINTENANCE CONSIDERATIONS

	[NOT YET AVAILABLE]

15.0	TERMINOLOGY

	GENERAL REGISTER - ONE OF THE EIGHT FAST PROCESSOR
			   REGISTERS 0-7 ON THE PDP-11.
	ANSI - AMERICAN NATIONAL STANDARDS INSTITUTE
	ASCII - AMERICAN STANDARD CODE FOR INFORMATION INTERCHANGE.
	DDT - DYNAMIC DEBUGGING TECHNIQUE.
	CREF - CROSS REFERENCE (LISTING).
	OTS - "OBJECT TIME SYSTEM", THAT PORTION OF THE FORTRAN
    